#include <vector>
#include <iostream>
#include <algorithm> // find_if
#include <sstream> // stringstream
#include <stack> // stack
#include <unordered_set> // unordered_set
#include <queue> // queue

using  namespace std;

//  左空格
void trimLeftTrailingSpaces(string &input) {
    input.erase(input.begin(), find_if(input.begin(), input.end(), [](int ch) {
        return !isspace(ch);
    }));
}

// 右空格
void trimRightTrailingSpaces(string &input) {
    input.erase(find_if(input.rbegin(), input.rend(), [](int ch) {
        return !isspace(ch);
    }).base(), input.end());
}

// 字符串串转一维整形向量
vector<int> stringToIntegerVector(string input) {
    vector<int> output;
    // 左边空格
    trimLeftTrailingSpaces(input);
    // 右边空格
    trimRightTrailingSpaces(input);
    // [] 去掉第一个[和最后 一个]
    input = input.substr(1, input.length() - 2);
    stringstream ss;
    ss.str(input);
    string item;
    char delim = ',';
    while (getline(ss, item, delim)) {
        output.push_back(stoi(item));
    }
    return output;
}

// 字符串转一维字符型向量
vector<string> stringToStringVector(string input) {
    vector<string> output;
    // 左边空格
    trimLeftTrailingSpaces(input);
    // 右边空格
    trimRightTrailingSpaces(input);
    // [] 去掉第一个[和最后 一个]
    input = input.substr(1, input.length() - 2);
    stringstream ss;
    ss.str(input);
    string item;
    char delim = ',';
    while (getline(ss, item, delim)) {
        output.push_back(item);
    }
    return output;
}

// 字符串转二维整形向量
vector<vector<int>> stringTo2dIntegerVector(string input2d) {
    vector<vector<int>> output2d;
    // 左边空格
    trimLeftTrailingSpaces(input2d);
    // 右边空格
    trimRightTrailingSpaces(input2d);
    // [] 去掉第一个[和最后 一个]
    input2d = input2d.substr(1, input2d.length() - 2);
    // 以,分割为向量
    vector<string> string1dVector = stringToStringVector(input2d);
    // 遍历转换为一维度整形向量
    for (string s : string1dVector) {
        vector<int> integer1dVector = stringToIntegerVector(s);
        output2d.push_back(integer1dVector);
    }

    return output2d;
}


// 一维整形向量转字符串
string integerVectorToString(vector<int> list, int length = -1) {
    if (length == -1) {
        length = list.size();
    }

    if (length == 0) {
        return "[]";
    }

    string result;
    for(int index = 0; index < length; index++) {
        int number = list[index];
        result += to_string(number) + ", ";
    }
    return "[" + result.substr(0, result.length() - 2) + "]";
}


// 一维字符型向量转字符串
string stringVectorToString(vector<string> list, int length = -1) {
    if (length == -1) {
        length = list.size();
    }

    if (length == 0) {
        return "[]";
    }

    string result;
    for(int index = 0; index < length; index++) {
        string numberString = list[index];
        result += numberString + ", ";
    }
    return "[" + result.substr(0, result.length() - 2) + "]";
}


// 连续输入的main函数
int main() {
    string line;
    while (getline(cin, line)) {
        // 命令的一维向量
        // ["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
        vector<string> command = stringToStringVector(line);
        // 二维金额 // 怎么处理3维的呢？？
        // [[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
        getline(cin, line);
        vector<vector<int>> bank2dInteger = stringTo2dIntegerVector(line);

        // 输出一维字符型向量
        cout << stringVectorToString(command) << endl;
        // 输出二维整型向量......???

    }
}



// 二叉树
/**
 * Definition for a binary tree node. */
struct TreeNode { // c++这二叉树不理解？？？
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};


// void trimLeftTrailingSpaces(string &input) {
//     input.erase(input.begin(), find_if(input.begin(), input.end(), [](int ch) {
//         return !isspace(ch);
//     }));
// }

// void trimRightTrailingSpaces(string &input) {
//     input.erase(find_if(input.rbegin(), input.rend(), [](int ch) {
//         return !isspace(ch);
//     }).base(), input.end());
// }

// 字符转二叉树
TreeNode* stringToTreeNode(string input) { // 更蒙逼了，再理解？？
    trimLeftTrailingSpaces(input);
    trimRightTrailingSpaces(input);
    input = input.substr(1, input.length() - 2);
    if (!input.size()) {
        return nullptr;
    }

    string item;
    stringstream ss;
    ss.str(input);

    getline(ss, item, ',');
    TreeNode* root = new TreeNode(stoi(item));
    queue<TreeNode*> nodeQueue;
    nodeQueue.push(root);

    while (true) {
        TreeNode* node = nodeQueue.front();
        nodeQueue.pop();

        if (!getline(ss, item, ',')) {
            break;
        }

        trimLeftTrailingSpaces(item);
        if (item != "null") {
            int leftNumber = stoi(item);
            node->left = new TreeNode(leftNumber);
            nodeQueue.push(node->left);
        }

        if (!getline(ss, item, ',')) {
            break;
        }

        trimLeftTrailingSpaces(item);
        if (item != "null") {
            int rightNumber = stoi(item);
            node->right = new TreeNode(rightNumber);
            nodeQueue.push(node->right);
        }
    }
    return root;
}
